#include <iostream>
using namespace std;

//饿汉
//定义一个静态的对象
// class Singleton{
// public:
//     static Singleton& getInstance(){
//         return _eton;
//     }

//     int getData(){
//         return _data;
//     }

// private:
//     Singleton():_data(1){}

//     ~Singleton(){}

//     Singleton(const Singleton &x) = delete;

// private:
//     static Singleton _eton;
//     int _data;
// };
// Singleton Singleton::_eton;
// int main(){
//     cout << Singleton::getInstance().getData() << endl;
//     return 0;
// }

//懒汉
//C++11之前：定义一个静态的对象指针，当访问的时候发现为空就实例化（需要注意线程安全）
//C++11之后：定义一个局部的静态对象，返回这个对象
class Singleton{
public:

    //仅在C++11之后支持：静态变量能在满足线程安全的前提下唯一的被构造和析构
    static Singleton& getInstance(){
        static Singleton _eton;
        return _eton;
    }

    int getData(){
        return _data;
    }

private:
    Singleton() : _data(1) { cout << "懒汉单例对象构造" << endl; }
    ~Singleton(){}
    Singleton(const Singleton &x) = delete;
private:
    int _data;
};

int main(){
    cout << Singleton::getInstance().getData() << endl;
    return 0;
}

//C++11之前的写法，加锁保证线程安全
// #include <pthread.h>

// class Singleton {
// public:
//     static Singleton& getInstance() {
//         //双检查加锁
//         if (instance == NULL){
//             pthread_mutex_lock(&mutex);
//             if (instance == NULL) {
//                 instance = new Singleton();
//             }
//         }
//         pthread_mutex_unlock(&mutex);
//         return *instance;
//     }

// private:
//     Singleton() {}  // 构造函数（被保护）

//     ~Singleton() {} // 析构函数
//     Singleton(const Singleton&); // 阻止复制
//     Singleton& operator=(const Singleton&); // 阻止赋值

//     static Singleton* instance;
//     static pthread_mutex_t mutex;
// };

// Singleton* Singleton::instance = NULL;
// pthread_mutex_t Singleton::mutex = PTHREAD_MUTEX_INITIALIZER;
